class BayesTreeMarginalizationHelper {
private:
  /**
   * Check if a clique contains variables that need reelimination due to
   * marginalization ordering conflicts.
   * 
   * @param[in] clique The clique to check
   * @param[in] marginalizableKeys Set of keys to be marginalized
   * @return true if any variables in the clique need re-elimination
   */
  static bool needsReelimination(
      const sharedClique& clique,
      const std::set<Key>& marginalizableKeys) {
    bool hasNonMarginalizableAhead = false;
    
    // Check each frontal variable in order
    for (Key key : clique->conditional()->frontals()) {
      if (marginalizableKeys.count(key)) {
        // If we've seen non-marginalizable variables before this one,
        // we need to reeliminate
        if (hasNonMarginalizableAhead) {
          return true;
        }
        
        // Check if any child depends on this marginalizable key
        if (hasChildDependency(clique, key)) {
          return true;
        }
      } else {
        hasNonMarginalizableAhead = true;
      }
    }
    return false;
  }

  /**
   * Check if any child clique depends on the given key.
   * 
   * @param[in] clique Parent clique to check
   * @param[in] key Key to check for dependencies
   * @return true if any child depends on the key
   */
  static bool hasChildDependency(
      const sharedClique& clique,
      Key key) {
    for (const sharedClique& child : clique->children) {
      auto parents = child->conditional();
      if (std::find(parents->beginParents(),
          parents->endParents(), key)
          != parents->endParents()) {
        return true;
      }
    }
    return false;
  }

  /**
   * Gather all dependent cliques that need re-elimination based on a root clique.
   * 
   * @param[in] rootClique The starting clique
   * @param[in] marginalizableKeys Set of keys to be marginalized
   * @param[out] dependentCliques Pointer to set storing dependent cliques
   * @param[out] additionalKeys Pointer to set storing keys that need reelimination
   */
  static void gatherDependentCliques(
      const sharedClique& rootClique,
      const std::set<Key>& marginalizableKeys,
      std::set<sharedClique>* dependentCliques,
      std::set<Key>* additionalKeys) {
    // Add frontal variables from current clique
    for (Key key : rootClique->conditional()->frontals()) {
      additionalKeys->insert(key);
      // Find children that depend on this key
      for (const sharedClique& child : rootClique->children) {
        if (!dependentCliques->count(child) &&
            hasChildDependency(rootClique, key)) {
          dependentCliques->insert(child);
        }
      }
    }
  }

  /**
   * Process all dependent cliques and gather their keys.
   * 
   * @param[in,out] dependentCliques Pointer to set of cliques to process
   * @return Set of keys from all dependent cliques
   */
  static std::set<Key> processDependentCliques(
      std::set<sharedClique>* dependentCliques) {
    std::set<Key> additionalKeys;
    
    while (!dependentCliques->empty()) {
      auto begin = dependentCliques->begin();
      sharedClique clique = *begin;
      dependentCliques->erase(begin);

      // Add all frontal variables from this clique
      for (Key key : clique->conditional()->frontals()) {
        additionalKeys.insert(key);
      }

      // Add all children for processing
      for (const sharedClique& child : clique->children) {
        dependentCliques->insert(child);
      }
    }
    
    return additionalKeys;
  }

public:
  /**
   * Get additional keys that need re-elimination when marginalizing variables.
   * 
   * This function identifies variables that need to be re-eliminated to ensure
   * proper marginalization order in two cases:
   * 
   * 1. When a child node depends on a variable being marginalized
   * 2. When non-marginalizable variables appear before marginalized ones
   * 
   * @param[in] bayesTree The Bayes tree
   * @param[in] marginalizableKeys Keys to be marginalized
   * @return Set of additional keys that need to be re-eliminated
   */
  static std::set<Key> gatherAdditionalKeysToReEliminate(
      const BayesTree& bayesTree,
      const KeyVector& marginalizableKeys) {
    const bool debug = ISDEBUG("BayesTreeMarginalizationHelper");
    
    std::set<Key> marginalizableKeySet(marginalizableKeys.begin(), 
                                     marginalizableKeys.end());
    std::set<sharedClique> checkedCliques;
    std::set<sharedClique> dependentCliques;
    std::set<Key> additionalKeys;

    // Check each marginalizable key's clique
    for (const Key& key : marginalizableKeySet) {
      sharedClique clique = bayesTree[key];
      if (checkedCliques.count(clique)) continue;
      
      checkedCliques.insert(clique);
      
      if (needsReelimination(clique, marginalizableKeySet)) {
        gatherDependentCliques(clique, marginalizableKeySet, 
                             &dependentCliques, &additionalKeys);
      }
    }

    // Process remaining dependent cliques
    auto dependentKeys = processDependentCliques(&dependentCliques);
    additionalKeys.insert(dependentKeys.begin(), dependentKeys.end());

    if (debug) {
      std::cout << "BayesTreeMarginalizationHelper: Additional keys to re-eliminate: ";
      for (const Key& key : additionalKeys) {
        std::cout << DefaultKeyFormatter(key) << " ";
      }
      std::cout << std::endl;
    }

    return additionalKeys;
  }
};